//
///**
// * Reads the value of an instance variable in an object.
// *
// * @param obj The object containing the instance variable whose value you want to read.
// * @param ivar The Ivar describing the instance variable whose value you want to read.
// *
// * @return The value of the instance variable specified by \e ivar, or \c nil if \e object is \c nil.
// *
// * @note \c object_getIvar is faster than \c object_getInstanceVariable if the Ivar
// *  for the instance variable is already known.
// */
//OBJC_EXPORT id object_getIvar(id obj, Ivar ivar)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Sets the value of an instance variable in an object.
// *
// * @param obj The object containing the instance variable whose value you want to set.
// * @param ivar The Ivar describing the instance variable whose value you want to set.
// * @param value The new value for the instance variable.
// *
// * @note \c object_setIvar is faster than \c object_setInstanceVariable if the Ivar
// *  for the instance variable is already known.
// */
//OBJC_EXPORT void object_setIvar(id obj, Ivar ivar, id value)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
///**
// * Obtains the list of registered class definitions.
// *
// * @param buffer An array of \c Class values. On output, each \c Class value points to
// *  one class definition, up to either \e bufferCount or the total number of registered classes,
// *  whichever is less. You can pass \c NULL to obtain the total number of registered class
// *  definitions without actually retrieving any class definitions.
// * @param bufferCount An integer value. Pass the number of pointers for which you have allocated space
// *  in \e buffer. On return, this function fills in only this number of elements. If this number is less
// *  than the number of registered classes, this function returns an arbitrary subset of the registered classes.
// *
// * @return An integer value indicating the total number of registered classes.
// *
// * @note The Objective-C runtime library automatically registers all the classes defined in your source code.
// *  You can create class definitions at runtime and register them with the \c objc_addClass function.
// *
// * @warning You cannot assume that class objects you get from this function are classes that inherit from \c NSObject,
// *  so you cannot safely call any methods on such classes without detecting that the method is implemented first.
// */
//OBJC_EXPORT int objc_getClassList(Class *buffer, int bufferCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);
//
//
///**
// * Creates and returns a list of pointers to all registered class definitions.
// *
// * @param outCount An integer pointer used to store the number of classes returned by
// *  this function in the list. It can be \c nil.
// *
// * @return A nil terminated array of classes. It must be freed with \c free().
// *
// * @see objc_getClassList
// */
//OBJC_EXPORT Class *objc_copyClassList(unsigned int *outCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_3_1);
//
//
//
//
//
//
///**
// * Sets the superclass of a given class.
// *
// * @param cls The class whose superclass you want to set.
// * @param newSuper The new superclass for cls.
// *
// * @return The old superclass for cls.
// *
// * @warning You should not use this function.
// */
//OBJC_EXPORT Class class_setSuperclass(Class cls, Class newSuper)
//__OSX_AVAILABLE_BUT_DEPRECATED(__MAC_10_5,__MAC_10_5, __IPHONE_2_0,__IPHONE_2_0);
//
//
//
//
///**
// * Returns a pointer to the data structure describing a given class method for a given class.
// *
// * @param cls A pointer to a class definition. Pass the class that contains the method you want to retrieve.
// * @param name A pointer of type \c SEL. Pass the selector of the method you want to retrieve.
// *
// * @return A pointer to the \c Method data structure that corresponds to the implementation of the
// *  selector specified by aSelector for the class specified by aClass, or NULL if the specified
// *  class or its superclasses do not contain an instance method with the specified selector.
// *
// * @note Note that this function searches superclasses for implementations,
// *  whereas \c class_copyMethodList does not.
// */
//OBJC_EXPORT Method class_getClassMethod(Class cls, SEL name)
//__OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);
//
//
//
//
//
//
//
///**
// * Returns a property with a given name of a given class.
// *
// * @param cls The class you want to inspect.
// * @param name The name of the property you want to inspect.
// *
// * @return A pointer of type \c objc_property_t describing the property, or
// *  \c NULL if the class does not declare a property with that name,
// *  or \c NULL if \e cls is \c Nil.
// */
//OBJC_EXPORT objc_property_t class_getProperty(Class cls, const char *name)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
///** 11.
// * Returns a description of the \c Ivar layout for a given class.
// *
// * @param cls The class to inspect.
// *
// * @return A description of the \c Ivar layout for \e cls.
// */
//OBJC_EXPORT const uint8_t *class_getIvarLayout(Class cls)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns a description of the layout of weak Ivars for a given class.
// *
// * @param cls The class to inspect.
// *
// * @return A description of the layout of the weak \c Ivars for \e cls.
// */
//OBJC_EXPORT const uint8_t *class_getWeakIvarLayout(Class cls)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
///**
// * Replaces the implementation of a method for a given class.
// *
// * @param cls The class you want to modify.
// * @param name A selector that identifies the method whose implementation you want to replace.
// * @param imp The new implementation for the method identified by name for the class identified by cls.
// * @param types An array of characters that describe the types of the arguments to the method.
// *  Since the function must take at least two arguments—self and _cmd, the second and third characters
// *  must be “@:” (the first character is the return type).
// *
// * @return The previous implementation of the method identified by \e name for the class identified by \e cls.
// *
// * @note This function behaves in two different ways:
// *  - If the method identified by \e name does not yet exist, it is added as if \c class_addMethod were called.
// *    The type encoding specified by \e types is used as given.
// *  - If the method identified by \e name does exist, its \c IMP is replaced as if \c method_setImplementation were called.
// *    The type encoding specified by \e types is ignored.
// */
//OBJC_EXPORT IMP class_replaceMethod(Class cls, SEL name, IMP imp,
//                                    const char *types)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Adds a new instance variable to a class.
// *
// * @return YES if the instance variable was added successfully, otherwise NO
// *         (for example, the class already contains an instance variable with that name).
// *
// * @note This function may only be called after objc_allocateClassPair and before objc_registerClassPair.
// *       Adding an instance variable to an existing class is not supported.
// * @note The class must not be a metaclass. Adding an instance variable to a metaclass is not supported.
// * @note The instance variable's minimum alignment in bytes is 1<<align. The minimum alignment of an instance
// *       variable depends on the ivar's type and the machine architecture.
// *       For variables of any pointer type, pass log2(sizeof(pointer_type)).
// */
//OBJC_EXPORT BOOL class_addIvar(Class cls, const char *name, size_t size,
//                               uint8_t alignment, const char *types)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
//
///**
// * Adds a property to a class.
// *
// * @param cls The class to modify.
// * @param name The name of the property.
// * @param attributes An array of property attributes.
// * @param attributeCount The number of attributes in \e attributes.
// *
// * @return \c YES if the property was added successfully, otherwise \c NO
// *  (for example, the class already has that property).
// */
//OBJC_EXPORT BOOL class_addProperty(Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * Replace a property of a class.
// *
// * @param cls The class to modify.
// * @param name The name of the property.
// * @param attributes An array of property attributes.
// * @param attributeCount The number of attributes in \e attributes.
// */
//OBJC_EXPORT void class_replaceProperty(Class cls, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * Sets the Ivar layout for a given class.
// *
// * @param cls The class to modify.
// * @param layout The layout of the \c Ivars for \e cls.
// */
//OBJC_EXPORT void class_setIvarLayout(Class cls, const uint8_t *layout)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Sets the layout for weak Ivars for a given class.
// *
// * @param cls The class to modify.
// * @param layout The layout of the weak Ivars for \e cls.
// */
//OBJC_EXPORT void class_setWeakIvarLayout(Class cls, const uint8_t *layout)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
//
///* Adding Classes */
//
///**
// * Used by Foundation's Key-Value Observing.
// *
// * @warning Do not call this function yourself.
// */
//OBJC_EXPORT Class objc_duplicateClass(Class original, const char *name, size_t extraBytes)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
///* Working with Methods */
//
///**
// * Returns the name of a method.
// *
// * @param m The method to inspect.
// *
// * @return A pointer of type SEL.
// *
// * @note To get the method name as a C string, call \c sel_getName(method_getName(method)).
// */
//OBJC_EXPORT SEL method_getName(Method m)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
//
///**
// * Returns a string describing a method's parameter and return types.
// *
// * @param m The method to inspect.
// *
// * @return A C string. The string may be \c NULL.
// */
//OBJC_EXPORT const char *method_getTypeEncoding(Method m)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns the number of arguments accepted by a method.
// *
// * @param m A pointer to a \c Method data structure. Pass the method in question.
// *
// * @return An integer containing the number of arguments accepted by the given method.
// */
//OBJC_EXPORT unsigned int method_getNumberOfArguments(Method m)
//__OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);
//
///**
// * Returns a string describing a method's return type.
// *
// * @param m The method to inspect.
// *
// * @return A C string describing the return type. You must free the string with \c free().
// */
//OBJC_EXPORT char *method_copyReturnType(Method m)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns a string describing a single parameter type of a method.
// *
// * @param m The method to inspect.
// * @param index The index of the parameter to inspect.
// *
// * @return A C string describing the type of the parameter at index \e index, or \c NULL
// *  if method has no parameter index \e index. You must free the string with \c free().
// */
//OBJC_EXPORT char *method_copyArgumentType(Method m, unsigned int index)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns by reference a string describing a method's return type.
// *
// * @param m The method you want to inquire about.
// * @param dst The reference string to store the description.
// * @param dst_len The maximum number of characters that can be stored in \e dst.
// *
// * @note The method's return type string is copied to \e dst.
// *  \e dst is filled as if \c strncpy(dst, parameter_type, dst_len) were called.
// */
//OBJC_EXPORT void method_getReturnType(Method m, char *dst, size_t dst_len)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns by reference a string describing a single parameter type of a method.
// *
// * @param m The method you want to inquire about.
// * @param index The index of the parameter you want to inquire about.
// * @param dst The reference string to store the description.
// * @param dst_len The maximum number of characters that can be stored in \e dst.
// *
// * @note The parameter type string is copied to \e dst. \e dst is filled as if \c strncpy(dst, parameter_type, dst_len)
// *  were called. If the method contains no parameter with that index, \e dst is filled as
// *  if \c strncpy(dst, "", dst_len) were called.
// */
//OBJC_EXPORT void method_getArgumentType(Method m, unsigned int index,
//                                        char *dst, size_t dst_len)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//OBJC_EXPORT struct objc_method_description *method_getDescription(Method m)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Sets the implementation of a method.
// *
// * @param m The method for which to set an implementation.
// * @param imp The implemention to set to this method.
// *
// * @return The previous implementation of the method.
// */
//OBJC_EXPORT IMP method_setImplementation(Method m, IMP imp)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Exchanges the implementations of two methods.
// *
// * @param m1 Method to exchange with second method.
// * @param m2 Method to exchange with first method.
// *
// * @note This is an atomic version of the following:
// *  \code
// *  IMP imp1 = method_getImplementation(m1);
// *  IMP imp2 = method_getImplementation(m2);
// *  method_setImplementation(m1, imp2);
// *  method_setImplementation(m2, imp1);
// *  \endcode
// */
//OBJC_EXPORT void method_exchangeImplementations(Method m1, Method m2)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
///* Working with Instance Variables */
//
///**
// * Returns the name of an instance variable.
// *
// * @param v The instance variable you want to enquire about.
// *
// * @return A C string containing the instance variable's name.
// */
//OBJC_EXPORT const char *ivar_getName(Ivar v)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns the type string of an instance variable.
// *
// * @param v The instance variable you want to enquire about.
// *
// * @return A C string containing the instance variable's type encoding.
// *
// * @note For possible values, see Objective-C Runtime Programming Guide > Type Encodings.
// */
//OBJC_EXPORT const char *ivar_getTypeEncoding(Ivar v)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///** 31.
// * Returns the offset of an instance variable.
// *
// * @param v The instance variable you want to enquire about.
// *
// * @return The offset of \e v.
// *
// * @note For instance variables of type \c id or other object types, call \c object_getIvar
// *  and \c object_setIvar instead of using this offset to access the instance variable data directly.
// */
//OBJC_EXPORT ptrdiff_t ivar_getOffset(Ivar v)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
///* Working with Properties */
//
///**
// * Returns the name of a property.
// *
// * @param property The property you want to inquire about.
// *
// * @return A C string containing the property's name.
// */
//OBJC_EXPORT const char *property_getName(objc_property_t property)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns the attribute string of a property.
// *
// * @param property A property.
// *
// * @return A C string containing the property's attributes.
// *
// * @note The format of the attribute string is described in Declared Properties in Objective-C Runtime Programming Guide.
// */
//OBJC_EXPORT const char *property_getAttributes(objc_property_t property)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns an array of property attributes for a property.
// *
// * @param property The property whose attributes you want copied.
// * @param outCount The number of attributes returned in the array.
// *
// * @return An array of property attributes; must be free'd() by the caller.
// */
//OBJC_EXPORT objc_property_attribute_t *property_copyAttributeList(objc_property_t property, unsigned int *outCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * Returns the value of a property attribute given the attribute name.
// *
// * @param property The property whose attribute value you are interested in.
// * @param attributeName C string representing the attribute name.
// *
// * @return The value string of the attribute \e attributeName if it exists in
// *  \e property, \c nil otherwise.
// */
//OBJC_EXPORT char *property_copyAttributeValue(objc_property_t property, const char *attributeName)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
//
///* Working with Protocols */
//
///**
// * Returns a specified protocol.
// *
// * @param name The name of a protocol.
// *
// * @return The protocol named \e name, or \c NULL if no protocol named \e name could be found.
// *
// * @note This function acquires the runtime lock.
// */
//OBJC_EXPORT Protocol *objc_getProtocol(const char *name)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns an array of all the protocols known to the runtime.
// *
// * @param outCount Upon return, contains the number of protocols in the returned array.
// *
// * @return A C array of all the protocols known to the runtime. The array contains \c *outCount
// *  pointers followed by a \c NULL terminator. You must free the list with \c free().
// *
// * @note This function acquires the runtime lock.
// */
//OBJC_EXPORT Protocol * __unsafe_unretained *objc_copyProtocolList(unsigned int *outCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns a Boolean value that indicates whether one protocol conforms to another protocol.
// *
// * @param proto A protocol.
// * @param other A protocol.
// *
// * @return \c YES if \e proto conforms to \e other, otherwise \c NO.
// *
// * @note One protocol can incorporate other protocols using the same syntax
// *  that classes use to adopt a protocol:
// *  \code
// *  @protocol ProtocolName < protocol list >
// *  \endcode
// *  All the protocols listed between angle brackets are considered part of the ProtocolName protocol.
// */
//OBJC_EXPORT BOOL protocol_conformsToProtocol(Protocol *proto, Protocol *other)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns a Boolean value that indicates whether two protocols are equal.
// *
// * @param proto A protocol.
// * @param other A protocol.
// *
// * @return \c YES if \e proto is the same as \e other, otherwise \c NO.
// */
//OBJC_EXPORT BOOL protocol_isEqual(Protocol *proto, Protocol *other)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns the name of a protocol.
// *
// * @param p A protocol.
// *
// * @return The name of the protocol \e p as a C string.
// */
//OBJC_EXPORT const char *protocol_getName(Protocol *p)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///** 41.
// * Returns a method description structure for a specified method of a given protocol.
// *
// * @param p A protocol.
// * @param aSel A selector.
// * @param isRequiredMethod A Boolean value that indicates whether aSel is a required method.
// * @param isInstanceMethod A Boolean value that indicates whether aSel is an instance method.
// *
// * @return An \c objc_method_description structure that describes the method specified by \e aSel,
// *  \e isRequiredMethod, and \e isInstanceMethod for the protocol \e p.
// *  If the protocol does not contain the specified method, returns an \c objc_method_description structure
// *  with the value \c {NULL, \c NULL}.
// *
// * @note This function recursively searches any protocols that this protocol conforms to.
// */
//OBJC_EXPORT struct objc_method_description protocol_getMethodDescription(Protocol *p, SEL aSel, BOOL isRequiredMethod, BOOL isInstanceMethod)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns an array of method descriptions of methods meeting a given specification for a given protocol.
// *
// * @param p A protocol.
// * @param isRequiredMethod A Boolean value that indicates whether returned methods should
// *  be required methods (pass YES to specify required methods).
// * @param isInstanceMethod A Boolean value that indicates whether returned methods should
// *  be instance methods (pass YES to specify instance methods).
// * @param outCount Upon return, contains the number of method description structures in the returned array.
// *
// * @return A C array of \c objc_method_description structures containing the names and types of \e p's methods
// *  specified by \e isRequiredMethod and \e isInstanceMethod. The array contains \c *outCount pointers followed
// *  by a \c NULL terminator. You must free the list with \c free().
// *  If the protocol declares no methods that meet the specification, \c NULL is returned and \c *outCount is 0.
// *
// * @note Methods in other protocols adopted by this protocol are not included.
// */
//OBJC_EXPORT struct objc_method_description *protocol_copyMethodDescriptionList(Protocol *p, BOOL isRequiredMethod, BOOL isInstanceMethod, unsigned int *outCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns the specified property of a given protocol.
// *
// * @param proto A protocol.
// * @param name The name of a property.
// * @param isRequiredProperty A Boolean value that indicates whether name is a required property.
// * @param isInstanceProperty A Boolean value that indicates whether name is a required property.
// *
// * @return The property specified by \e name, \e isRequiredProperty, and \e isInstanceProperty for \e proto,
// *  or \c NULL if none of \e proto's properties meets the specification.
// */
//OBJC_EXPORT objc_property_t protocol_getProperty(Protocol *proto, const char *name, BOOL isRequiredProperty, BOOL isInstanceProperty)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns an array of the properties declared by a protocol.
// *
// * @param proto A protocol.
// * @param outCount Upon return, contains the number of elements in the returned array.
// *
// * @return A C array of pointers of type \c objc_property_t describing the properties declared by \e proto.
// *  Any properties declared by other protocols adopted by this protocol are not included. The array contains
// *  \c *outCount pointers followed by a \c NULL terminator. You must free the array with \c free().
// *  If the protocol declares no properties, \c NULL is returned and \c *outCount is \c 0.
// */
//OBJC_EXPORT objc_property_t *protocol_copyPropertyList(Protocol *proto, unsigned int *outCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns an array of the protocols adopted by a protocol.
// *
// * @param proto A protocol.
// * @param outCount Upon return, contains the number of elements in the returned array.
// *
// * @return A C array of protocols adopted by \e proto. The array contains \e *outCount pointers
// *  followed by a \c NULL terminator. You must free the array with \c free().
// *  If the protocol declares no properties, \c NULL is returned and \c *outCount is \c 0.
// */
//OBJC_EXPORT Protocol * __unsafe_unretained *protocol_copyProtocolList(Protocol *proto, unsigned int *outCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Creates a new protocol instance that cannot be used until registered with
// * \c objc_registerProtocol()
// *
// * @param name The name of the protocol to create.
// *
// * @return The Protocol instance on success, \c nil if a protocol
// *  with the same name already exists.
// * @note There is no dispose method for this.
// */
//OBJC_EXPORT Protocol *objc_allocateProtocol(const char *name)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * Registers a newly constructed protocol with the runtime. The protocol
// * will be ready for use and is immutable after this.
// *
// * @param proto The protocol you want to register.
// */
//OBJC_EXPORT void objc_registerProtocol(Protocol *proto)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * Adds a method to a protocol. The protocol must be under construction.
// *
// * @param proto The protocol to add a method to.
// * @param name The name of the method to add.
// * @param types A C string that represents the method signature.
// * @param isRequiredMethod YES if the method is not an optional method.
// * @param isInstanceMethod YES if the method is an instance method.
// */
//OBJC_EXPORT void protocol_addMethodDescription(Protocol *proto, SEL name, const char *types, BOOL isRequiredMethod, BOOL isInstanceMethod)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * Adds an incorporated protocol to another protocol. The protocol being
// * added to must still be under construction, while the additional protocol
// * must be already constructed.
// *
// * @param proto The protocol you want to add to, it must be under construction.
// * @param addition The protocol you want to incorporate into \e proto, it must be registered.
// */
//OBJC_EXPORT void protocol_addProtocol(Protocol *proto, Protocol *addition)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * Adds a property to a protocol. The protocol must be under construction.
// *
// * @param proto The protocol to add a property to.
// * @param name The name of the property.
// * @param attributes An array of property attributes.
// * @param attributeCount The number of attributes in \e attributes.
// * @param isRequiredProperty YES if the property (accessor methods) is not optional.
// * @param isInstanceProperty YES if the property (accessor methods) are instance methods.
// *  This is the only case allowed fo a property, as a result, setting this to NO will
// *  not add the property to the protocol at all.
// */
//OBJC_EXPORT void protocol_addProperty(Protocol *proto, const char *name, const objc_property_attribute_t *attributes, unsigned int attributeCount, BOOL isRequiredProperty, BOOL isInstanceProperty)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
//
///* Working with Libraries */
//
///** 51
// * Returns the names of all the loaded Objective-C frameworks and dynamic
// * libraries.
// *
// * @param outCount The number of names returned.
// *
// * @return An array of C strings of names. Must be free()'d by caller.
// */
//OBJC_EXPORT const char **objc_copyImageNames(unsigned int *outCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns the dynamic library name a class originated from.
// *
// * @param cls The class you are inquiring about.
// *
// * @return The name of the library containing this class.
// */
//OBJC_EXPORT const char *class_getImageName(Class cls)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Returns the names of all the classes within a library.
// *
// * @param image The library or framework you are inquiring about.
// * @param outCount The number of class names returned.
// *
// * @return An array of C strings representing the class names.
// */
//OBJC_EXPORT const char **objc_copyClassNamesForImage(const char *image,
//                                                     unsigned int *outCount)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
///* Working with Selectors */
//
///**
// * Returns the name of the method specified by a given selector.
// *
// * @param sel A pointer of type \c SEL. Pass the selector whose name you wish to determine.
// *
// * @return A C string indicating the name of the selector.
// */
//OBJC_EXPORT const char *sel_getName(SEL sel)
//__OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);
//
///**
// * Registers a method name with the Objective-C runtime system.
// *
// * @param str A pointer to a C string. Pass the name of the method you wish to register.
// *
// * @return A pointer of type SEL specifying the selector for the named method.
// *
// * @note The implementation of this method is identical to the implementation of \c sel_registerName.
// * @note Prior to OS X version 10.0, this method tried to find the selector mapped to the given name
// *  and returned \c NULL if the selector was not found. This was changed for safety, because it was
// *  observed that many of the callers of this function did not check the return value for \c NULL.
// */
//OBJC_EXPORT SEL sel_getUid(const char *str)
//__OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);
//
///**
// * Registers a method with the Objective-C runtime system, maps the method
// * name to a selector, and returns the selector value.
// *
// * @param str A pointer to a C string. Pass the name of the method you wish to register.
// *
// * @return A pointer of type SEL specifying the selector for the named method.
// *
// * @note You must register a method name with the Objective-C runtime system to obtain the
// *  method’s selector before you can add the method to a class definition. If the method name
// *  has already been registered, this function simply returns the selector.
// */
//OBJC_EXPORT SEL sel_registerName(const char *str)
//__OSX_AVAILABLE_STARTING(__MAC_10_0, __IPHONE_2_0);
//
///**
// * Returns a Boolean value that indicates whether two selectors are equal.
// *
// * @param lhs The selector to compare with rhs.
// * @param rhs The selector to compare with lhs.
// *
// * @return \c YES if \e rhs and \e rhs are equal, otherwise \c NO.
// *
// * @note sel_isEqual is equivalent to ==.
// */
//OBJC_EXPORT BOOL sel_isEqual(SEL lhs, SEL rhs)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
//
///* Objective-C Language Features */
//
///**
// * This function is inserted by the compiler when a mutation
// * is detected during a foreach iteration. It gets called
// * when a mutation occurs, and the enumerationMutationHandler
// * is enacted if it is set up. A fatal error occurs if a handler is not set up.
// *
// * @param obj The object being mutated.
// *
// */
//OBJC_EXPORT void objc_enumerationMutation(id obj)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Sets the current mutation handler.
// *
// * @param handler Function pointer to the new mutation handler.
// */
//OBJC_EXPORT void objc_setEnumerationMutationHandler(void (*handler)(id))
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Set the function to be called by objc_msgForward.
// *
// * @param fwd Function to be jumped to by objc_msgForward.
// * @param fwd_stret Function to be jumped to by objc_msgForward_stret.
// *
// * @see message.h::_objc_msgForward
// */
//OBJC_EXPORT void objc_setForwardHandler(void *fwd, void *fwd_stret)
//__OSX_AVAILABLE_STARTING(__MAC_10_5, __IPHONE_2_0);
//
///**
// * Creates a pointer to a function that will call the block
// * when the method is called.
// *
// * @param block The block that implements this method. Its signature should
// *  be: method_return_type ^(id self, method_args...).
// *  The selector is not available as a parameter to this block.
// *  The block is copied with \c Block_copy().
// *
// * @return The IMP that calls this block. Must be disposed of with
// *  \c imp_removeBlock.
// */
//OBJC_EXPORT IMP imp_implementationWithBlock(id block)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * Return the block associated with an IMP that was created using
// * \c imp_implementationWithBlock.
// *
// * @param anImp The IMP that calls this block.
// *
// * @return The block called by \e anImp.
// */
//OBJC_EXPORT id imp_getBlock(IMP anImp)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * Disassociates a block from an IMP that was created using
// * \c imp_implementationWithBlock and releases the copy of the
// * block that was created.
// *
// * @param anImp An IMP that was created using \c imp_implementationWithBlock.
// *
// * @return YES if the block was released successfully, NO otherwise.
// *  (For example, the block might not have been used to create an IMP previously).
// */
//OBJC_EXPORT BOOL imp_removeBlock(IMP anImp)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_4_3);
//
///**
// * This loads the object referenced by a weak pointer and returns it, after
// * retaining and autoreleasing the object to ensure that it stays alive
// * long enough for the caller to use it. This function would be used
// * anywhere a __weak variable is used in an expression.
// *
// * @param location The weak pointer address
// *
// * @return The object pointed to by \e location, or \c nil if \e location is \c nil.
// */
//OBJC_EXPORT id objc_loadWeak(id *location)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0);
//
///** 65
// * This function stores a new value into a __weak variable. It would
// * be used anywhere a __weak variable is the target of an assignment.
// *
// * @param location The address of the weak pointer itself
// * @param obj The new object this weak ptr should now point to
// *
// * @return The value stored into \e location, i.e. \e obj
// */
//OBJC_EXPORT id objc_storeWeak(id *location, id obj)
//__OSX_AVAILABLE_STARTING(__MAC_10_7, __IPHONE_5_0);
//
//
///* Associative References */
//
///**
// * Policies related to associative references.
// * These are options to objc_setAssociatedObject()
// */
//typedef OBJC_ENUM(uintptr_t, objc_AssociationPolicy) {
//    OBJC_ASSOCIATION_ASSIGN = 0,           /**< Specifies a weak reference to the associated object. */
//    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1, /**< Specifies a strong reference to the associated object.
//                                            *   The association is not made atomically. */
//    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,   /**< Specifies that the associated object is copied.
//                                            *   The association is not made atomically. */
//    OBJC_ASSOCIATION_RETAIN = 01401,       /**< Specifies a strong reference to the associated object.
//                                            *   The association is made atomically. */
//    OBJC_ASSOCIATION_COPY = 01403          /**< Specifies that the associated object is copied.
//                                            *   The association is made atomically. */
//    };
//    
//